const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');
const archiver = require('archiver');
const rimraf = require('rimraf');

console.log('开始创建独立可执行文件...');

// 目标目录
const targetDir = path.join(__dirname, '../dist-exe-' + Date.now());
const sourceDir = path.join(__dirname, '../dist');
const tempDir = path.join(__dirname, '../temp-build-' + Date.now());

// 清理目标目录
if (fs.existsSync(targetDir)) {
  console.log('正在清理目标目录...');
  try {
    fs.rmSync(targetDir, { recursive: true, force: true });
    console.log('清理完成');
  } catch (err) {
    console.error('清理目录失败:', err);
  }
}

// 创建目标目录
console.log('创建目标目录...');
fs.mkdirSync(targetDir, { recursive: true });

// 清理临时目录
if (fs.existsSync(tempDir)) {
  console.log('正在清理临时目录...');
  try {
    rimraf.sync(tempDir);
    console.log('清理完成');
  } catch (err) {
    console.error('清理临时目录失败:', err);
  }
}

// 创建临时目录
console.log('创建临时目录...');
fs.mkdirSync(tempDir, { recursive: true });

// 复制package.json到dist目录
console.log('准备package.json...');
const packageJson = require('../package.json');
// 只保留NW.js所需的字段，并添加扩展配置
const nwPackage = {
  name: packageJson.name,
  version: packageJson.version,
  main: 'index.html',
  'node-remote': [
    '*://localhost/*',
    'http://127.0.0.1:*/*'
  ],
  'chromium-args': '--disable-web-security --allow-file-access-from-files --ignore-certificate-errors',
  window: packageJson.window
};
fs.writeFileSync(path.join(sourceDir, 'package.json'), JSON.stringify(nwPackage, null, 2));

// 创建应用压缩包
console.log('创建应用压缩包...');
const zipFilePath = path.join(tempDir, 'app.nw');
const output = fs.createWriteStream(zipFilePath);
const archive = archiver('zip', {
  zlib: { level: 9 }
});

// 处理警告和错误
archive.on('warning', function(err) {
  if (err.code === 'ENOENT') {
    console.warn('警告:', err);
  } else {
    throw err;
  }
});

archive.on('error', function(err) {
  throw err;
});

// 完成压缩事件处理
output.on('close', function() {
  console.log('应用压缩包创建完成，大小: ' + (archive.pointer() / 1024 / 1024).toFixed(2) + ' MB');
  
  // 使用项目中已有的NW.js
  console.log('检查NW.js...');
  
  try {
    // 查找本地NW.js
    const nwSourcePath = path.join(__dirname, '../node_modules/nw');
    if (!fs.existsSync(nwSourcePath)) {
      throw new Error(`未找到NW.js: ${nwSourcePath}，请确保已运行npm install`);
    }

    console.log(`找到NW.js目录: ${nwSourcePath}`);
    
    // 查找nw.exe
    let nwExePath = '';
    const searchPaths = [
      path.join(nwSourcePath, 'nw.exe'),
      path.join(nwSourcePath, 'nwjs/nw.exe'),
      path.join(nwSourcePath, 'bin/nw.exe')
    ];
    
    for (const p of searchPaths) {
      if (fs.existsSync(p)) {
        nwExePath = p;
        console.log(`找到nw.exe: ${nwExePath}`);
        break;
      }
    }
    
    if (!nwExePath) {
      // 递归查找nw.exe
      const findNwExe = (dir) => {
        if (!fs.existsSync(dir)) return null;
        const files = fs.readdirSync(dir);
        for (const file of files) {
          const fullPath = path.join(dir, file);
          if (file === 'nw.exe') {
            return fullPath;
          } else if (fs.statSync(fullPath).isDirectory()) {
            const result = findNwExe(fullPath);
            if (result) return result;
          }
        }
        return null;
      };
      
      nwExePath = findNwExe(nwSourcePath);
      if (nwExePath) {
        console.log(`通过递归搜索找到nw.exe: ${nwExePath}`);
      } else {
        throw new Error('无法找到nw.exe');
      }
    }
    
    // 获取NW.js根目录（包含所有依赖文件的目录）
    const nwjsRoot = path.dirname(nwExePath);
    console.log(`NW.js根目录: ${nwjsRoot}`);
    
    // 创建可执行文件
    console.log('创建可执行文件...');
    const exePath = path.join(targetDir, packageJson.name + '.exe');
    
    // 复制nw.exe作为基础
    fs.copyFileSync(nwExePath, exePath);
    
    // 合并exe和app.nw
    console.log('合并exe和应用文件...');
    const exeStream = fs.createWriteStream(exePath, { flags: 'a' });
    const appStream = fs.createReadStream(zipFilePath);
    
    appStream.pipe(exeStream);
    
    appStream.on('end', function() {
      console.log('合并完成');
      
      // 复制其他依赖文件
      console.log('复制依赖文件...');
      // 列出NW.js根目录中的所有文件
      const nwjsFiles = fs.readdirSync(nwjsRoot);
      
      for (const file of nwjsFiles) {
        if (file !== 'nw.exe' && file !== 'nwjc.exe') {
          const srcPath = path.join(nwjsRoot, file);
          const destPath = path.join(targetDir, file);
          
          try {
            if (fs.statSync(srcPath).isDirectory()) {
              fs.cpSync(srcPath, destPath, { recursive: true });
            } else {
              fs.copyFileSync(srcPath, destPath);
            }
          } catch (err) {
            console.warn(`复制 ${file} 失败:`, err);
          }
        }
      }
      
      console.log('打包完成!');
      console.log(`可执行文件已生成: ${exePath}`);
      
      // 清理临时目录
      console.log('清理临时文件...');
      try {
        rimraf.sync(tempDir);
        console.log('临时文件清理完成');
      } catch (error) {
        console.warn('清理临时目录失败:', error);
      }
    });
  } catch (error) {
    console.error('创建可执行文件失败:', error);
    process.exit(1);
  }
});

// 管道写入
archive.pipe(output);

// 添加文件到压缩包
archive.directory(sourceDir, false);

// 完成压缩
archive.finalize(); 